from demo import models
import json

# 类视图
from django.shortcuts import render
from django.views import View
from django.http import HttpResponse, JsonResponse


"""
1 没有使用DRF视图，使用的是django原生视图View
2 没有使用了DRF序列化器

配置步骤：
查（列表视图）
1 查询出所有图书模型，得到一个查询集。
2 遍历查询集，取出里面的每个书籍模型对象，把模型对象转换成python字典。
3 响应，将python字典转换成JSON格式。

增（列表视图）
1 获取前端传来的JSON_Bytes(Bytes类型的JSON数据)。
2 把JSON_Bytes 转换成 JSON_Str(String类型的JSON数据)。
3 利用 Json模块 json.loads 将 JSON_Str 转换成 python字典。
4 创建模型对象，把 python字典 转换成 django模型，并保存。
5 再将 新增的django模型 转换为 python字典。
6 响应，将python字典转换成JSON格式，响应码201。

查（详情视图）
1 查询出某个pk的图书模型，得到一个模型对象。
2 把模型对象转换成python字典。
3 响应，将python字典转换成JSON格式。

删
1 查询出某个pk的图书模型，得到一个模型对象。
2 删除模型对象。
3 响应，删除不需要有响应体，但是必须给个状态，例如204。

改
1 查询出某个pk的图书模型，得到一个模型对象。
2 获取前端传来的JSON_Bytes(Bytes类型的JSON数据)，最终转换成python字典。
3 重新给 模型对象 赋值（按照python字典），这里只列举两个。
4 修改后的 模型对象 保存。
5 把模型对象转换成python字典。
6 响应，将python字典转换成JSON格式。

"""
class BookListView(View):
    '''
    列表视图
    '''
    def get(self, request):
        '''
        查询所有图书
        :param request:
        :return:
        '''

        # 1 查询出所有图书模型，得到一个查询集
        bookall = models.Book.objects.all()

        # 2 遍历查询集，取出里面的每个书籍模型对象，把模型对象转换成python字典。
        # 定义一个列表，用来装载图书字典
        book_list = []
        for book in bookall:
            book_dict = {
                'id': book.id,
                'bookname': book.bookname,
                'price': book.price,
            }
            book_list.append(book_dict)

        # 响应，将python字典转换成JSON格式。
        # 因为顶层括号是[]，所以safe=False
        return JsonResponse(book_list, safe=False)

    def post(self, request):
        '''
        新增图书接口
        :param request:
        :return:
        '''
        # 1 获取前端传来的JSON_Bytes(Bytes类型的JSON数据)。
        json_b = request.body
        print(json_b)
        """
        格式为：
        b'    {\n        "bookname": "hujing123",\n        "price": "1234567"\n    }'
        """

        # 2 把JSON_Bytes 转换成 JSON_Str(String类型的JSON数据)。
        json_str = json_b.decode()
        print(json_str)
        """
        格式为：
        {
        "bookname": "hujing123",
        "price": "1234567"
        }
        """

        # 3 利用 Json模块 json.loads 将 JSON_Str 转换成 python字典。
        book_dict = json.loads(json_str)
        print(book_dict)
        """
        格式为：
        {'bookname': 'hujing123', 'price': '1234567'}
        """

        # 4 创建模型对象，把 python字典 转换成 django模型，并保存。
        book = models.Book(
            bookname=book_dict['bookname'],
            price=book_dict['price'],
        )
        book.save()

        # 5 再将 新增的django模型 转换为 python字典。
        json_dict = {
            'id': book.id,
            'bookname': book.bookname,
            'price': book.price,
        }

        # 6 响应，将python字典转换成JSON格式，响应码201。
        return JsonResponse(json_dict, status=201)

class BookDetailView(View):
    '''
    详情视图
    '''
    def get(self, request, pk):
        '''
        查询单一图书
        :param request:
        :return:
        '''
        # 1 查询出某个pk的图书模型，得到一个模型对象。
        try:
            book = models.Book.objects.get(id=pk)
        except:
            return HttpResponse({'message': '查询的数据不存在'}, status=404)

        # 2 把模型对象转换成python字典。
        book_dict = {
            'id': book.id,
            'bookname': book.bookname,
            'price': book.price,
        }

        # 3 响应，将python字典转换成JSON格式。
        return JsonResponse(book_dict, safe=False)

    def delete(self, request, pk):
        '''
        删除图书接口
        :param request:
        :return:
        '''
        # 1 获取出指定pk的那个模型对象
        try:
            book = models.Book.objects.get(id=pk)
        except:
            return HttpResponse({'message': '查询的数据不存在'}, status=404)

        # 2 删除模型对象
        # 物理删除，即删除数据库中的数据
        book.delete()
        # # 逻辑删除
        # book.is_delete = True
        # book.save()

        # 3 响应，删除不需要有响应体，但是必须给个状态，例如204
        return HttpResponse(status=204)

    def put(self, request, pk):
        '''
        修改单一图书，最复杂的方法
        :param request:
        :return:
        '''
        # 1 查询出某个pk的图书模型，得到一个模型对象。
        try:
            book = models.Book.objects.get(id=pk)
        except:
            return HttpResponse({'message': '查询的数据不存在'}, status=404)

        # 2 获取前端传来的Bytes类型的JSON数据，最终转换成字典
        json_b = request.body
        json_str = json_b.decode()
        book_dict = json.loads(json_str)
        # 可以合成一行 book_dict = json.loads(request.body.decode())

        # 3 重新给 模型对象 赋值（按照python字典），这里只列举两个。
        # book.title = book_dict['title']
        book.author = book_dict['author']

        # 4 修改后的 模型对象 保存。
        book.save()

        # 5 把模型对象转换成python字典。
        book_dict = {
            'id': book.id,
            'bookname': book.bookname,
            'price': book.price,
        }

        # 6 响应，将python字典转换成JSON格式。
        return JsonResponse(book_dict)